home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume11 / graphedit / part03 < prev    next >
Encoding:
Internet Message Format  |  1987-10-05  |  29.0 KB
  1. Subject:  v11i099:  Graphics editor for Suns, Part03/06
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rs@uunet.UU.NET
  5.  
  6. Submitted-by: steinmetz!sbcs!nyfca1!chan (Douglas Chan)
  7. Posting-number: Volume 11, Issue 99
  8. Archive-name: graphedit/part03
  9.  
  10. [  Note the /tmp/catshar, and the way that "draw.c" is split into two
  11.    files.  Douglas did a nice packing jobs on this submission.  --r$  ]
  12.  
  13. # This is a shell archive.  Remove anything before this line,
  14. # then unpack it by saving it in a file and typing "sh file".
  15. #
  16. # Contents:  draw.c.shar2 /tmp/catshar
  17.  
  18. echo x - draw.c.shar2
  19. sed 's/^@//' > "draw.c.shar2" <<'@//E*O*F draw.c.shar2//'
  20.     /* create segment for the text sample if it is not there */
  21.     if ( !(dlist=ge_display_list(GE_CHAR_SAMPLE)) ) {
  22.       make_new_seg(GE_CHAR_SAMPLE);
  23.       dlist=ge_display_list(GE_CHAR_SAMPLE);
  24.       ge_graph(GE_CHAR_SAMPLE, GE_MOVE, TEXTX, TEXTY);
  25.       ge_graph(GE_CHAR_SAMPLE, GE_TEXT, (float)((int)text_sample), 0.);
  26.     } /* if */
  27.  
  28.     /* change font of text sample and draw sample */
  29.     dlist->attr.font=value;
  30.     attr_changed = 1;
  31.     ge_draw(GE_CHAR_SAMPLE);
  32.  
  33. } /* do_change_font */
  34.  
  35. /*****************************************************************************
  36.  
  37.     do_change_charsize is the notify procedure of the slider for character
  38.   size.  It will create the text sample if it is not there and update the
  39.   size of the test sample according to the value of the slider.
  40.  
  41. *****************************************************************************/
  42.  
  43. do_change_charsize(item, value, event)
  44. Panel_item item;
  45. int value;
  46. Event *event;
  47. {
  48.     struct list *dlist;
  49.  
  50.     /* create segment for text sample if it is not there */
  51.     if ( !(dlist=ge_display_list(GE_CHAR_SAMPLE)) ) {
  52.       make_new_seg(GE_CHAR_SAMPLE);
  53.       dlist=ge_display_list(GE_CHAR_SAMPLE);
  54.       ge_graph(GE_CHAR_SAMPLE, GE_MOVE, TEXTX, TEXTY);
  55.       ge_graph(GE_CHAR_SAMPLE, GE_TEXT, (float)((int)text_sample), 0.);
  56.     }
  57.  
  58.     /* change character size of text sample and draw sample */
  59.     dlist->attr.charsize=value;
  60.     attr_changed = 1;
  61.     ge_draw(GE_CHAR_SAMPLE);
  62.  
  63. } /* do_change_charsize */
  64.  
  65. /*****************************************************************************
  66.  
  67.     do_change_linestyle is the notify procedure of the linestyle choice.
  68.   It will create the line sample if it is not there and update the line
  69.   style of the line sample according to the value chosen.
  70.  
  71. *****************************************************************************/
  72.  
  73. /* define coordinates of line sample */
  74. #define LINEX 80.
  75. #define LINEY 370.
  76.  
  77. do_change_linestyle(item, value, event)
  78. Panel_item item;
  79. int value;
  80. Event *event;
  81. {
  82.     struct list *dlist;
  83.  
  84.     /* create segment for line sample if it is not there */
  85.     if ( !(dlist=ge_display_list(GE_LINE_SAMPLE)) ) {
  86.       make_new_seg(GE_LINE_SAMPLE);
  87.       dlist=ge_display_list(GE_LINE_SAMPLE);
  88.       ge_graph(GE_LINE_SAMPLE, GE_MOVE, LINEX, LINEY);
  89.       ge_graph(GE_LINE_SAMPLE, GE_LINE, LINEX+60., LINEY);
  90.     }
  91.  
  92.     /* update line style of line sample and draw sample */
  93.     dlist->attr.linestyle=value;
  94.     attr_changed = 1;
  95.     ge_draw(GE_LINE_SAMPLE);
  96.  
  97. } /* do_change_linestyle */
  98.  
  99. /*****************************************************************************
  100.  
  101.     do_change_linewidth is the notify procedure of the slider for line widths.
  102.   It will create the line sample if it is not there and update the line
  103.   width of the line sample according to the value of the slider.
  104.  
  105. *****************************************************************************/
  106.  
  107. do_change_linewidth(item, value, event)
  108. Panel_item item;
  109. int value;
  110. Event *event;
  111. {
  112.     struct list *dlist;
  113.  
  114.     /* create segment for the line sample if necessary */
  115.     if ( !(dlist=ge_display_list(GE_LINE_SAMPLE)) ) {
  116.       make_new_seg(GE_LINE_SAMPLE);
  117.       dlist=ge_display_list(GE_LINE_SAMPLE);
  118.       ge_graph(GE_LINE_SAMPLE, GE_MOVE, LINEX, LINEY);
  119.       ge_graph(GE_LINE_SAMPLE, GE_LINE, LINEX+60., LINEY);
  120.     } /* if */
  121.  
  122.     /* update line width of line sample and draw sample */
  123.     dlist->attr.linewidth=value;
  124.     attr_changed = 1;
  125.     ge_draw(GE_LINE_SAMPLE);
  126.  
  127. } /* do_change_linewidth */
  128.  
  129.  
  130. /*****************************************************************************
  131.  
  132.     do_break is used to break a segment into segments with one primitive
  133.   in each segment.  It scans the display list of the segment looking for
  134.   instructions such as GE_MOVE and GE_POLYGON which imply the beginning
  135.   of a primitive and create a new segment for it.
  136.  
  137. *****************************************************************************/
  138.  
  139. do_break()
  140. {
  141.   int segnam;
  142.   struct list *dlist;
  143.   struct list_item *ptr;
  144.   struct attr attr;
  145.   int fill;
  146.  
  147.   do_message("");
  148.   /* ask for number of segment to break */
  149.   do_usage("Select segment","","");
  150.   if ( ! (segnam=ge_pick()) ) {
  151.     do_usage("","","");
  152.     do_message("No segment selected.");
  153.     return; 
  154.   } /* if */
  155.   do_usage("","","");
  156.  
  157.   /* delete segment from view surface */
  158.   dlist = ge_display_list(segnam);
  159.   attr = dlist->attr;
  160.   attr.drawn = 0;
  161.   dlist->attr.deleted=1;
  162.   ge_draw(segnam);
  163.  
  164.   if ( ptr=dlist->d_list ) {
  165.     ptr=ptr->next;
  166.     segopen = FALSE;
  167.     fill = 0;
  168.  
  169.     /* scan the display list to create the new segments */
  170.     do {
  171.       switch ( ptr->instr ) {
  172.  
  173.         /* create new segment at GE_MOVE and GE_PLOT */
  174.         case GE_MOVE:
  175.         case GE_PLOT:
  176.           if ( segopen )
  177.             ge_draw(opensegment);
  178.           make_new_seg(0);
  179.           curr_dlist->attr=attr;
  180.           break;
  181.  
  182.         case GE_POLYGON:
  183.           /* create new segment at GE_POLYGON */
  184.           if ( segopen )
  185.             ge_draw(opensegment);
  186.           make_new_seg(0);
  187.           curr_dlist->attr=attr;
  188.  
  189.         case GE_CIRCLE:
  190.         case GE_ELLIPSE:
  191.           /* set up the proper fill instruction for polygon, circle
  192.              and ellipse */
  193.           if (fill) {
  194.             ge_graph(opensegment, GE_FILL, (float)fill, 0.);
  195.             fill = 0;
  196.           }
  197.           break;
  198.  
  199.         /* no special action for these instructions */
  200.         case GE_LINE:
  201.         case GE_POLYLINE:
  202.         case GE_TEXT:
  203.         case GE_CONT:
  204.         case GE_ARC:
  205.         case GE_ARCEXT:
  206.           break;
  207.  
  208.         /* save the fill instruction value, which will be used by
  209.            the next polygon, circle or ellipse */
  210.         case GE_FILL:
  211.           fill = (int)ptr->x;
  212.           break;
  213.  
  214.         /* save any change of attributes, which will be used as the
  215.            initial attributes of the next created segment */
  216.         case GE_SETCOLOR:
  217.           attr.color=(int)ptr->x;
  218.           break;
  219.         case GE_SETTYPELINE:
  220.           attr.linestyle=(int)ptr->x;
  221.           break;
  222.         case GE_SETLINEWIDTH:
  223.           attr.linewidth=(int)ptr->x;
  224.           break;
  225.         case GE_SETFONT:
  226.           attr.font=(int)ptr->x;
  227.           break;
  228.         case GE_SETCHARSIZE:
  229.           attr.charsize=(int)ptr->x;
  230.           break;
  231.  
  232.         /* check that all possible instructions are properly handled */
  233.         default:
  234.           fprintf(stderr,
  235.                   "Internal Error-Action for instruction %d missing.\n",
  236.                   ptr->instr);
  237.           break;
  238.  
  239.       } /* switch */
  240.  
  241.       /* add instruction to the current segment */
  242.       ge_graph(opensegment, ptr->instr, ptr->x, ptr->y);
  243.       ptr=ptr->next;
  244.  
  245.     } while (ptr != dlist->d_list->next);
  246.  
  247.   } /* if */
  248.  
  249.   /* draw the last segment created */
  250.   ge_draw(opensegment);
  251.  
  252.   /* delete the old segment */
  253.   ge_delete_segment(segnam);
  254.   segopen = FALSE;
  255.  
  256.   /* repeat if the continous option is on */
  257.   if ( panel_get_value(cycle_cont) ) do_break();
  258.  
  259. } /* do_break */
  260.  
  261. /*****************************************************************************
  262.  
  263.     ge_newscale is used to determine the scaling factor for radius of circles
  264.   or character size of text when a segment is joined to another segment.
  265.  
  266.   Input
  267.     sx1, sy1 - x,y scale of segment to be joined
  268.     sx2, sy2 - x,y scale of segment joining to the first segment
  269.  
  270.   Output
  271.     Return the scaling factor determined.
  272.  
  273. *****************************************************************************/
  274.  
  275. float ge_newscale(sx1, sy1, sx2, sy2)
  276. float sx1, sy1, sx2, sy2;
  277. {
  278.   return (sqrt((double)
  279.               ((sx2 * sx2 + sy2 * sy2)/
  280.                (sx1 * sx1 + sy1 * sy1))));
  281.  
  282. } /* ge_newscale */
  283.  
  284. /*****************************************************************************
  285.  
  286.     do_join is used to join a number of segments to form one segment.  It will
  287.   ask the user to pick the first segment.  The display list of all the following
  288.   segments picked will be appended to the display list of the first segment
  289.   after any apporpiate changes.  It will finish when the user do not pick any
  290.   segment or pick the first segment.
  291.  
  292. *****************************************************************************/
  293.  
  294. do_join()
  295. {
  296.   int segnam, firstsegment;
  297.   struct list *dlist, *first_dlist;
  298.   struct list_item *ptr;
  299.   struct attr attr;
  300.   float sina, cosa;
  301.  
  302.   /* ask the user to pick the first segment */
  303.   do_message("");
  304.   do_usage("First segment","","");
  305.   if ( ! (firstsegment=ge_pick()) ) {
  306.     /* abort if no segment picked */
  307.     do_usage("","","");
  308.     do_message("No segment selected.");
  309.     return;
  310.   } /* if */
  311.  
  312.   /* get the display list of the first segment */
  313.   segopen = FALSE;
  314.   first_dlist = ge_display_list(firstsegment);
  315.   curr_dlist = first_dlist;
  316.   attr = first_dlist->attr;
  317.  
  318.   /* update attr according to display list of first segment 
  319.      to obtain attributes at the end of the display list */
  320.   if ( ptr=first_dlist->d_list ) {
  321.     ptr=ptr->next;
  322.     do {
  323.  
  324.       switch ( ptr->instr ) {
  325.         case GE_SETCOLOR:
  326.           attr.color = (int) ptr->x;
  327.           break;
  328.         case GE_SETTYPELINE:
  329.           attr.linestyle = (int) ptr->x;
  330.           break;
  331.         case GE_SETLINEWIDTH:
  332.           attr.linewidth = (int) ptr->x;
  333.           break;
  334.         case GE_SETFONT:
  335.           attr.font = (int) ptr->x;
  336.           break;
  337.         case GE_SETCHARSIZE:
  338.           attr.charsize = (int) ptr->x;
  339.           break;
  340.         default: break;
  341.       } /* switch */
  342.       ptr=ptr->next;
  343.  
  344.     } while ( ptr != first_dlist->d_list->next );
  345.  
  346.   } /* if */
  347.  
  348.   /* ask user to pick a number of segments to join */
  349.   do_message("Select first or no segment when done.");
  350.   do_usage("Select segment", "", "");
  351.  
  352.   /* join until user pick no/first segment */
  353.   while (((segnam=ge_pick()) && (segnam != firstsegment))) {
  354.  
  355.     float newscale;
  356.  
  357.     dlist = ge_display_list(segnam);
  358.     newscale=ge_newscale(dlist->attr.sx, dlist->attr.sy, attr.sx, attr.sy);
  359.  
  360.     /* change character size of new segment according to the difference
  361.        in scale between the two segments */
  362.     dlist->attr.charsize = (float)dlist->attr.charsize / newscale;
  363.  
  364.     /* change attributes of the first segment to the initial attributes
  365.        of the joining segment */
  366.     if ( dlist->attr.color != attr.color ) {
  367.       ge_graph(firstsegment, GE_SETCOLOR, (float)dlist->attr.color, 0.);
  368.       attr.color = dlist->attr.color;
  369.     }
  370.     if ( dlist->attr.linestyle != attr.linestyle ) {
  371.       ge_graph(firstsegment, GE_SETTYPELINE, (float)dlist->attr.linestyle, 0.);
  372.       attr.linestyle = dlist->attr.linestyle;
  373.     }
  374.     if ( dlist->attr.linewidth != attr.linewidth ) {
  375.       ge_graph(firstsegment, GE_SETLINEWIDTH, (float)dlist->attr.linewidth, 0.);
  376.       attr.linewidth = dlist->attr.linewidth;
  377.     }
  378.     if ( dlist->attr.font != attr.font ) {
  379.       ge_graph(firstsegment, GE_SETFONT, (float)dlist->attr.font, 0.);
  380.       attr.font = dlist->attr.font;
  381.     }
  382.     if ( dlist->attr.charsize != attr.charsize ) {
  383.       ge_graph(firstsegment, GE_SETCHARSIZE, (float)dlist->attr.charsize, 0.);
  384.       attr.charsize = dlist->attr.charsize;
  385.     }
  386.  
  387.     sina = sin((double)dlist->attr.ang);
  388.     cosa = cos((double)dlist->attr.ang);
  389.  
  390.     /* append the display list of the joining segment to the display list
  391.        of the first segment */
  392.     if ( ptr=dlist->d_list ) {
  393.       ptr=ptr->next;
  394.       do {
  395.  
  396.         float nx, ny, wx, wy;
  397.  
  398.         /* add item to segment */
  399.         switch ( ptr->instr ) {
  400.           case GE_MOVE:
  401.           case GE_LINE:
  402.           case GE_PLOT:
  403.           case GE_POLYLINE:
  404.           case GE_POLYGON:
  405.           case GE_CONT:
  406.             /* transform point to world coordinate */
  407.             wx = dlist->attr.sx * cosa * ptr->x -
  408.                  dlist->attr.sy * sina * ptr->y + dlist->attr.tx;
  409.             wy = dlist->attr.sx * sina * ptr->x +
  410.                  dlist->attr.sy * cosa * ptr->y + dlist->attr.ty;
  411.             unxform(wx,wy,&nx,&ny);
  412.             break;
  413.  
  414.           case GE_CIRCLE:
  415.           case GE_ARCEXT:
  416.             /* the radius has to be scaled according to the difference
  417.                in scale */
  418.             nx = ptr->x /  newscale;
  419.             ny = ptr->y;
  420.             break;
  421.  
  422.           case GE_ELLIPSE:
  423.             /* scale height and width of ellipse according to the
  424.                difference in scale */
  425.             nx = ptr->x * dlist->attr.sx / attr.sx;
  426.             ny = ptr->y * dlist->attr.sy / attr.sy;
  427.             break;
  428.  
  429.           case GE_ARC:
  430.             /* change starting and ending angle of arc according to
  431.                the difference in rotation */
  432.             nx = ptr->x + dlist->attr.ang - attr.ang;
  433.             ny = ptr->y + dlist->attr.ang - attr.ang;
  434.             break;
  435.  
  436.           case GE_TEXT:
  437.           case GE_FILL:
  438.             /* nothing has to be changed */
  439.             nx = ptr->x; ny = ptr->y;
  440.             break;
  441.  
  442.           /* update current attribute of first segment */
  443.           case GE_SETCOLOR:
  444.             attr.color = (int) ptr->x;
  445.             nx = ptr->x; ny = ptr->y;
  446.             break;
  447.           case GE_SETTYPELINE:
  448.             attr.linestyle = (int) ptr->x;
  449.             nx = ptr->x; ny = ptr->y;
  450.             break;
  451.           case GE_SETLINEWIDTH:
  452.             attr.linewidth = (int) ptr->x;
  453.             nx = ptr->x; ny = ptr->y;
  454.             break;
  455.           case GE_SETFONT:
  456.             attr.font = (int) ptr->x;
  457.             nx = ptr->x; ny = ptr->y;
  458.             break;
  459.           case GE_SETCHARSIZE:
  460.             /* character size has to be scaled according to difference
  461.                in scale */
  462.             ptr->x /= newscale;
  463.             attr.charsize = (int) ptr->x;
  464.             nx = ptr->x; ny = ptr->y;
  465.             break;
  466.  
  467.           /* check that all instuctions are properly handled */
  468.           default:
  469.             fprintf(stderr,
  470.                     "Internal Error-Action for instruction %d missing.\n",
  471.                     ptr->instr);
  472.             break;
  473.  
  474.         } /* switch */
  475.  
  476.         /* add instruction to first segment */
  477.         ge_graph(firstsegment, ptr->instr, nx, ny);
  478.         ptr=ptr->next;
  479.  
  480.       } while ( ptr != dlist->d_list->next );
  481.  
  482.     }  /* if */
  483.  
  484.     /* delete the segment */
  485.     dlist->attr.deleted = 1;
  486.     ge_draw(segnam);
  487.     ge_delete_segment(segnam);
  488.  
  489.     /* redraw first segment */
  490.     ge_draw(firstsegment);
  491.  
  492.   } /* while */
  493.  
  494.   do_message("");
  495.   do_usage("","","");
  496.  
  497. } /* do_join */
  498.  
  499. /*****************************************************************************
  500.  
  501.     do_clear will ask for confirmation of the clear and delete all
  502.   segments (except the samples) from the display list and the view
  503.   surface upon confirmation.
  504.  
  505. *****************************************************************************/
  506.  
  507. do_clear()
  508. {
  509.   int i, tmp;
  510.   extern int ge_seglist;
  511.   extern struct list ge_open[];
  512.  
  513.   do_message("");
  514.   if (!(wmgr_confirm(basefd,"Press the left mouse button to confirm Clear.  To cancel, press the right mouse button now."))) {
  515.     /* clear is cancelled */
  516.     do_message("Cancelled.");
  517.     return;
  518.   } /* if */
  519.  
  520.   /* scan the segment list to delete all segments */
  521.   for ( i=ge_seglist; i; i=tmp ) {
  522.  
  523.     tmp = ge_open[i].next;
  524.  
  525.     /* samples are excluded */
  526.     if ( ge_open[i].segno >= GE_MIN_SEG ) {
  527.  
  528.       /* remove segment from display */
  529.       ge_open[i].attr.deleted=1;
  530.       ge_draw(ge_open[i].segno);
  531.  
  532.       /* remove segment from segment list */
  533.       ge_delete_segment(ge_open[i].segno);
  534.  
  535.     } /* if */
  536.   } /* for */
  537.   segopen=FALSE;
  538.  
  539. } /* do_clear */
  540.  
  541. /*****************************************************************************
  542.  
  543.     do_copy_segment is used to make a copy of a segment.  It will ask the
  544.   user to pick a segment, create a new segment and copy the display list of
  545.   the old segment to the new segment, and ask the user to move the new
  546.   segment to its proper position.
  547.  
  548. *****************************************************************************/
  549.  
  550. do_copy_segment()
  551. {
  552.     int segnam, butnum;
  553.         float tx0, ty0, tx, ty, x, y, wx, wy;
  554.         struct list *dlist,*newdlist;
  555.         struct list_item *ptr;
  556.  
  557.         /* ask for number of segment to copy */
  558.         do_message("");
  559.         do_usage("Select segment","","");
  560.     if (segnam=ge_pick() ) {
  561.  
  562.           ge_locator(-1, &butnum, &wx, &wy);
  563.  
  564.           /* create new segment */
  565.           make_new_seg(0);
  566.           segopen=FALSE;
  567.  
  568.           /* copy display list and attributes to new segment */
  569.           dlist = ge_display_list(segnam);
  570.           newdlist = ge_display_list(opensegment);
  571.           newdlist->attr = dlist->attr;
  572.           newdlist->attr.drawn = 0;
  573.           if ( ptr=dlist->d_list ) {
  574.             ptr=ptr->next;
  575.             do {
  576.               ge_graph(opensegment, ptr->instr, ptr->x, ptr->y);
  577.               ptr=ptr->next;
  578.             } while ( ptr != dlist->d_list->next );
  579.           }
  580.  
  581.           /* draw new segment */
  582.           ge_draw(opensegment);
  583.  
  584.           /* ask to user to move the new segment */
  585.           tx0 = newdlist->attr.tx; ty0 = newdlist->attr.ty;
  586.           do_message("Move the new segment to its location.");
  587.           do_usage("", "", "Done");
  588.           do {
  589.             float tx, ty;
  590.  
  591.             /* determine amount of movement */
  592.             ge_locator(-1,&butnum, &x, &y);
  593.             tx = x-wx;
  594.             ty = y-wy;
  595.             ge_align(&tx,&ty);
  596.         dlist->attr.tx = tx0 + tx;
  597.             dlist->attr.ty = ty0 + ty;
  598.  
  599.             /* redraw both segments */
  600.             ge_redisplay(newdlist);
  601.             ge_redisplay(dlist);
  602.  
  603.           } while ( butnum != 3 );
  604.           segopen = FALSE;
  605.           do_message("");
  606.         }
  607.         else {
  608.           do_message("No segment selected.");
  609.         }
  610.  
  611.         do_usage("","","");
  612.  
  613.         /* repeat if the continous option is on */
  614.         if ( segnam && panel_get_value(cycle_cont) )
  615.           do_copy_segment();
  616.  
  617. } /* do_copy_segment */
  618.  
  619. /*****************************************************************************
  620.  
  621.     do_open_file is used to open a file with its name in the file name
  622.   field on the control pad.  It will check whether the file name is
  623.   typed in and ask the user to confirm if the file already exist.
  624.  
  625.   Output
  626.     Return stream of opened file if the open is successful, and 0 otherwise.
  627.  
  628. *****************************************************************************/
  629.  
  630. FILE *do_open_file()
  631. {
  632.   char *string;
  633.   FILE *file;
  634.  
  635.   /* get file name in file field on control pad */
  636.   string=(char *)panel_get_value(text_filen);
  637.  
  638.   /* check for empty file name */
  639.   if ( string[0] == '\0' ) {
  640.     do_message("Empty file name.");
  641.     return(0);
  642.   }
  643.  
  644.   /* ask user to confirm if file exist */
  645.   if ( !(access(string, F_OK) || wmgr_confirm(basefd,"Press the left mouse button to remove file.  To cancel, press the right mouse button now.")) ) {
  646.     do_message("Cancelled.");
  647.     return(0);
  648.   }
  649.  
  650.   /* try to open the file */
  651.   if ( !(file=fopen(string, "w+")) ) {
  652.     do_message("Cannot open file.");
  653.     return(0);
  654.   }
  655.  
  656.   return(file);
  657.  
  658. } /* do_open_file */
  659.  
  660. /*****************************************************************************
  661.  
  662.     do_save_seg will ask the user to pick a segment to save and save
  663.   it in the file indicated in the file field on the control pad.
  664.  
  665. *****************************************************************************/
  666.  
  667. do_save_seg()
  668. {
  669.  
  670.     extern int errno;
  671.         FILE *onfile;
  672.         int segno;
  673.  
  674.         /* ask the user to pick a segment */
  675.         do_message("");
  676.         do_usage("Select segment","","");
  677.         if ( (segno=ge_pick()) < GE_MIN_SEG ) {
  678.           do_usage("","","");
  679.           do_message("No segment selected.");
  680.           return;
  681.         }
  682.         do_usage("","","");
  683.  
  684.         /* try to open file */
  685.         if ( !(onfile=do_open_file()) ) {
  686.           /* abort if file cannot be openned */
  687.           return;
  688.         }
  689.  
  690.         /* write segment to file */
  691.         ps_write_seg(onfile,segno);
  692.  
  693.         /* close file */
  694.         fclose(onfile);
  695.  
  696.         do_message("Segment saved.");
  697.  
  698. } /* do_save_seg */
  699.  
  700. /*****************************************************************************
  701.  
  702.     do_restore will load a segment from the file indicated in the file
  703.   field on the control pad.
  704.  
  705. *****************************************************************************/
  706.  
  707. do_restore_seg()
  708. {
  709.  
  710.     char *string;
  711.     extern int errno;
  712.         FILE *onfile;
  713.  
  714.         /* get file name from file field on control pad */
  715.         string=(char *)panel_get_value(text_filen);
  716.  
  717.         /* try to open file */
  718.         if (!(onfile=fopen(string, "r"))) {
  719.           do_message("Cannot open file.");
  720.           return;
  721.         }
  722.  
  723.         /* load segment */
  724.         if ( ! ps_load(onfile) ) {
  725.           do_message("Segment loaded.");
  726.         }
  727.         else {
  728.           do_message("File is not a saved segment.");
  729.         }
  730.  
  731.         /* close file */
  732.         fclose(onfile);
  733.         segopen = FALSE;
  734.  
  735. } /* do_restore_seg */
  736.  
  737. /*****************************************************************************
  738.  
  739.     do_save_pic will save the picture in the file indicated in the file
  740.   field on the control pad.  It will run the optimize routine to optimize
  741.   the display list if the optimize option is on.
  742.  
  743. *****************************************************************************/
  744.  
  745. do_save_pic()
  746. {
  747.  
  748.         FILE *onfile;
  749.         extern Panel_item cycle_optm;
  750.  
  751.         /* try to open file in the file field */
  752.         if ( !(onfile=do_open_file()) ) {
  753.           return;
  754.         }
  755.  
  756.         /* run the optimize routine to optimize the display list if
  757.            the optimize option is on */
  758.         if ( (int)panel_get_value(cycle_optm) ) {
  759.           optimize();
  760.         }
  761.  
  762.         /* save the picture */
  763.         ps_write(onfile);
  764.  
  765.         /* close the file */
  766.         fclose(onfile);
  767.  
  768.         do_message("Saved.");
  769.  
  770. } /* do_save_pic */
  771.  
  772. /*****************************************************************************
  773.  
  774.     do_restore_pic will load the picture from the file indicated in the
  775.   file name field on the control pad.
  776.  
  777. *****************************************************************************/
  778.  
  779. do_restore_pic()
  780. {
  781.  
  782.     char *string;
  783.     extern int errno;
  784.         FILE *onfile;
  785.  
  786.         /* get the file indicated in the file field */
  787.         string=(char *)panel_get_value(text_filen);
  788.         if (!(onfile=fopen(string, "r"))) {
  789.           do_message("Cannot open file.");
  790.           return;
  791.         }
  792.  
  793.         /* load picture */
  794.         if ( ! ps_load(onfile) ) {
  795.           do_message("Picture loaded.");
  796.           segopen = FALSE;
  797.         }
  798.         else {
  799.           do_message("File is not a saved picture.");
  800.         }
  801.  
  802.         /* close file */
  803.         fclose(onfile);
  804.  
  805. } /* do_restore_pic */
  806.  
  807. /*****************************************************************************
  808.  
  809.     do_raster will write the pixrect image of whole/part of the picture on
  810.   the already opened onfile.  It will remove the samples and grid from
  811.   the view surface and refresh the view surface before getting the
  812.   pixrect image.
  813.  
  814.   Input
  815.     onfile - opened stream for writing
  816.  
  817. *****************************************************************************/
  818.  
  819. do_raster(onfile)
  820. FILE *onfile;
  821. {
  822.   float xmin, ymin, xmax, ymax;
  823.   int butnum,i;
  824.   extern Panel_item cycle_raster;
  825.  
  826.   /* display list of samples */
  827.   struct {
  828.     int deleted;
  829.     struct list *dlist;
  830.   } samples[4];
  831.  
  832.   /* segments which should be invisible on the raster file */
  833.   static int sampleseg[] = {GE_COLOR_SAMPLE,GE_LINE_SAMPLE,
  834.     GE_CHAR_SAMPLE, GE_GRID};
  835.  
  836.   /* set region to dump */
  837.   xmin=0.; ymin=0.;
  838.   if ( (int)panel_get_value(cycle_raster) ) {
  839.  
  840.     /* ask for region to dump when raster option is on */
  841.     do_usage("Reset corner","","Done");
  842.     do {
  843.  
  844.       xmax=xmin;
  845.       ymax=ymin;
  846.       ge_locator(6, &butnum, &xmax, &ymax);
  847.       if ( butnum == 1 ) {
  848.         /* reset corner */
  849.         xmin=xmax;
  850.         ymin=ymax;
  851.       }
  852.  
  853.     } while ( butnum != 3 );
  854.     do_usage("","","");
  855.  
  856.   }
  857.  
  858.   else {
  859.     /* dump the whole view surface */
  860.     xmax=GE_WIN_X;
  861.     ymax=GE_WIN_Y;
  862.   }
  863.  
  864.   /* remove the samples from the view surface */
  865.   for ( i=0; i<4; i++ ) {
  866.     if ( (samples[i].dlist = ge_display_list(sampleseg[i])) &&
  867.          ! (samples[i].deleted = samples[i].dlist->attr.deleted)){
  868.       samples[i].dlist->attr.deleted = 1;
  869.       ge_draw(sampleseg[i]);
  870.     } /* if */
  871.   } /* for */
  872.  
  873.   /* refresh the screen */
  874.   ge_refresh();
  875.  
  876.   /* dump the region to onfile */
  877.   core_write(onfile, xmin, ymin, xmax, ymax);
  878.  
  879.   /* redraw the samples and grid */
  880.   for ( i=0; i<4; i++ ) {
  881.     if ( samples[i].dlist && (!samples[i].deleted) ) {
  882.       samples[i].dlist->attr.deleted = 0;
  883.       ge_draw(sampleseg[i]);
  884.     } /* if */
  885.   } /* for */
  886.  
  887. } /* do_raster */
  888.  
  889. /*****************************************************************************
  890.  
  891.     do_output will write the picture in the format specified by the
  892.   output format option to the file indicated in the file field on the
  893.   control pad.  It will try to open the file, and then call the
  894.   corresponding routine to write the picture.
  895.  
  896. *****************************************************************************/
  897.  
  898. do_output()
  899. {
  900.   extern Panel_item cycle_output;
  901.  
  902.   int format;
  903.   FILE *onfile;
  904.   FILE savestdout;
  905.  
  906.   do_message("");
  907.  
  908.   /* open the file indicated in the file field on the control pad */
  909.   if ( !(onfile=do_open_file()) ) {
  910.     return;
  911.   } /* if */
  912.  
  913.   /* get the format from the output format option */
  914.   format=(int)panel_get_value(cycle_output);
  915.  
  916.   switch ( format ) {
  917.     case 0:
  918.       /* raster file */
  919.       do_raster(onfile);
  920.       break;
  921.  
  922.     case 1:
  923.       /* pic */
  924.       pic_write(onfile);
  925.       fclose(onfile);
  926.       break;
  927.     case 2:
  928.       /* plot */
  929.  
  930.       /* make onfile the standard output file so that the plot library will
  931.          write to onfile */
  932.       savestdout = *stdout;
  933.       *stdout = *onfile;
  934.  
  935.       plt_write();
  936.  
  937.       /* reset standard output */
  938.       *stdout=savestdout;
  939.       break;
  940.  
  941.   } /* switch */
  942.  
  943.   do_message("Written");
  944.  
  945. } /* do_output */
  946.  
  947. /*****************************************************************************
  948.  
  949.     do_global_scale will scale and move the whole picture within a rectangular
  950.   region specified by the user.
  951.  
  952. *****************************************************************************/
  953.  
  954. do_global_scale()
  955. {
  956.   float xmin, ymin, xmax, ymax;
  957.   float tmp, sx, sy, tx, ty;
  958.   int butnum,i;
  959.  
  960.   /* ask for the region to scale to */
  961.   do_message("");
  962.   do_usage("Reset corner","Cancel","Done");
  963.   xmin=0.; ymin=0.;
  964.   do {
  965.     xmax=xmin;
  966.     ymax=ymin;
  967.     ge_locator(6, &butnum, &xmax, &ymax);
  968.     if ( butnum == 1 ) {
  969.       /* reset corner */
  970.       xmin=xmax;
  971.       ymin=ymax;
  972.     }
  973.     if ( butnum == 2 ) {
  974.       /* cancel scale */
  975.       do_usage("","","");
  976.       do_message("Cancelled.");
  977.       return;
  978.     }
  979.   } while ( butnum != 3 );
  980.   do_usage("","","");
  981.  
  982.   /* get lower left corner in (xmin,ymin) and upper right corner in
  983.      (xmax,ymax) */
  984.   if ( xmin > xmax ) {
  985.     tmp=xmin;
  986.     xmin=xmax;
  987.     xmax=tmp;
  988.   }
  989.   if ( ymin > ymax ) {
  990.     tmp=ymin;
  991.     ymin=ymax;
  992.     ymax=tmp;
  993.   }
  994.  
  995.   /* determine the scale and movement */
  996.   sx = (xmax - xmin)/GE_WIN_X;
  997.   sy = (ymax - ymin)/GE_WIN_Y;
  998.   tx = xmin;
  999.   ty = ymin;
  1000.  
  1001.   /* scan the segment list to scale all segments except the
  1002.      samples */
  1003.   for ( i=ge_seglist; i; i=ge_open[i].next ) {
  1004.     if ( ge_open[i].segno >= GE_MIN_SEG ) {
  1005.       float sina, cosa, nx, ny;
  1006.  
  1007.       sina=sin((double)ge_open[i].attr.ang);
  1008.       cosa=cos((double)ge_open[i].attr.ang);
  1009.  
  1010.       /* determine the new translate value, scaling at (0,0)
  1011.          in world coordinate */
  1012.       nx = (-ge_open[i].attr.tx*cosa - ge_open[i].attr.ty*sina)/
  1013.            ge_open[i].attr.sx;
  1014.       ny = (-ge_open[i].attr.ty*cosa + ge_open[i].attr.tx*sina)/
  1015.            ge_open[i].attr.sy;
  1016.       ge_open[i].attr.tx += nx*cosa*ge_open[i].attr.sx*(1-sx) -
  1017.                             ny*sina*ge_open[i].attr.sy*(1-sy) + tx;
  1018.       ge_open[i].attr.ty += nx*sina*ge_open[i].attr.sx*(1-sx) +
  1019.                             ny*cosa*ge_open[i].attr.sy*(1-sy) + ty;
  1020.  
  1021.       /* determine the new scale factor */
  1022.       ge_open[i].attr.sx *= sx;
  1023.       ge_open[i].attr.sy *= sy;
  1024.  
  1025.       /* redraw segment */
  1026.       ge_redisplay(&(ge_open[i]));
  1027.  
  1028.     } /* if */
  1029.  
  1030.   } /* for */
  1031.  
  1032. } /* do_global_scale */
  1033. @//E*O*F draw.c.shar2//
  1034. chmod u=rw,g=r,o=r draw.c.shar2
  1035.  
  1036. echo x - /tmp/catshar
  1037. sed 's/^@//' > "/tmp/catshar" <<'@//E*O*F /tmp/catshar//'
  1038. #!/bin/csh
  1039. #
  1040. # This script combine draw.c.shar1 and draw.c.shar2 together
  1041. if ( -f draw.c.shar1 && -f draw.c.shar2 ) then
  1042. echo 'Reconstruct draw.c from draw.c.shar1 and draw.c.shar2...'
  1043. cat draw.c.shar1 draw.c.shar2 >> draw.c
  1044. /bin/rm -f draw.c.shar1 draw.c.shar2
  1045. endif
  1046. exit 0
  1047. @//E*O*F /tmp/catshar//
  1048. chmod u=rwx,g=rx,o=rx /tmp/catshar
  1049.  
  1050. echo Inspecting for damage in transit...
  1051. temp=/tmp/shar$$; dtemp=/tmp/.shar$$
  1052. trap "rm -f $temp $dtemp; exit" 0 1 2 3 15
  1053. cat > $temp <<\!!!
  1054.     1013    3155   28120 draw.c.shar2
  1055.        9      38     275 catshar
  1056.     1022    3193   28395 total
  1057. !!!
  1058. wc  draw.c.shar2 /tmp/catshar | sed 's=[^ ]*/==' | diff -b $temp - >$dtemp
  1059. if [ -s $dtemp ]
  1060. then echo "Ouch [diff of wc output]:" ; cat $dtemp
  1061. else echo "No problems found."
  1062. fi
  1063. /tmp/catshar
  1064. /bin/rm -f /tmp/catshar
  1065. exit 0
  1066.  
  1067.  
  1068.